約 4,619,033 件
https://w.atwiki.jp/forzamotorsport4/pages/51.html
プライズカー一覧 レベル1～50まで、レベルアップごとに数台の候補の中から1台だけ選択してプライズカーが貰えます。 車名の横にある数字はディーラーでの販売価格です。プライズカーを選択する際の目安にしてください。 DLCのマシンがインストールされていると候補に追加されるので、気付いたらリストの更新をお願いします。 （※DLCの配信時期によって特定の車がリストから消える場合もあるとの報告あり） ディーラーの車とは違い、ベース車と同じクラスのPI上限までクイックアップグレードが施されています。 Level 1 - スポーツ スーパーミニ Level 2 - 初級チューナー Level 3 - クラシック スポーツ クーペ Level 4 - コンパクト ホット ハッチ Level 5 - フライデー ナイト クルーザー Level 6 - トランザム伝説 Level 7 - ドリフトの先駆け Level 8 - トラックの王者 Level 9 - アメリカン マッスルの神髄 Level 10 - 新鮮なデザイン Level 11 - 歴史的なラリー アイコン Level 12 - 初期ツーリングカー Level 13 - スポーツ オフローダー Level 14 - 上級チューナー Level 15 - アメリカン ドラッグ レーサー Level 16 - イタリアン マッスル Level 17 - フェザー級 Level 18 - 10年越しのライバル Level 19 - 究極のホット ハッチ Level 20 - 街道のスペシャリスト Level 21 - モダン アメリカン マッスル Level 22 - モダン スポーツ セダン Level 23 - モダン スポーツ クーペ Level 24 - 高級スポーツサルーン Level 25 - 1980年代のピンナップ Level 26 - 忘れ難いスタイル Level 27 - 高級ラグジュアリークーペ Level 28 - レース実証済みのテクノロジー Level 29 - スーパー スポーツ クーペ Level 30 - ル マンの伝説 Level 31 - ハイパーカーのパイオニア Level 32 - リングの王者 Level 33 - アイコニック コンセプト Level 34 - 究極のGT Level 35 - ブティック スーパーカー Level 36 - 最上位モデル Level 37 - 公道レースカー Level 38 - モダン GT2 Level 39 - ワールド レコード候補 Level 40 - オーストラリア V8 スーパーカー Level 41 - ブティック ハイパーカー (2012年7月時点) Level 42 - アメリカン ストックカー Level 43 - ドイツ ツーリングカー Level 44 - 初期 GT1 Level 45 - Super GT500 Level 46 - GT1 ライバル Level 47 - 究極のハイパーカー Level 48 - 初期 LMP1 Level 49 - モダン LMP2 Level 50 - モダン LMP1 Level 1 - スポーツ スーパーミニ * 2008 Toyota Yaris S - 10,000 * 2009 Ford Fiesta Zetec S - 19,000 * 2011 Suzuki SX4 Sportback - 14,000 * 2010 FIAT Punto Evo SPORT - 20,000 * 2011 Mazda 2 - 14,000 * 2009 Honda Fit Sport - 12,000 * 2009 Scion xD - 11,000 Level 2 - 初級チューナー * 1992 Volkswagen Golf GTi 16v Mk2 - 6,000 * 1989 Toyota MR2 SC - 6,000 * 1994 Mazda MX-5 Miata - 7,000 * 1994 Nissan 240SX SE - 7,000 * 1994 Honda Civic 1.5 VTi - 5,000 Level 3 - クラシック スポーツ クーペ * 1969 Nissan Fairlady Z 432 - 12,000 * 1965 Alfa Romeo Giulia Sprint GTA Stradale - 60,000 * 1973 BMW 2002 Turbo - 28,000 * 1971 Nissan Skyline 2000GT-R - 28,000 * 1971 Lotus Elan Sprint - 30,000 Level 4 - コンパクト ホット ハッチ * 2009 SEAT Ibiza CUPRA - 17,000 * 2009 Renault Twingo Renault Sport Cup - 16,000 * 2008 Alfa Romeo MiTo - 20,000 * 2011 Citroen DS3 - 24,000 * 2010 Mitsubishi Colt Ralliart - 22,000 Level 5 - フライデー ナイト クルーザー * 1966 Chevrolet Nova SS - 78,000(The American Muscle Car Pack) * 1965 Ford Mustang GT Coupe - 26,000(Bonus Car Pack) * 1960 Chevrolet Corvette - 80,000 * 1957 Ford Thunderbird - 60,000 * 1965 Pontiac GTO - 44,000(The American Muscle Car Pack) Level 6 - トランザム伝説 * 1970 Mercury Cougar Eliminator - 48,000 * 1969 Pontiac Firebird Trans Am - 45,000 * 1970 Ford Mustang Boss 429 - 120,000 * 1969 Chevrolet Camaro Z28 - 12,000 * 1971 AMC Javelin-AMX - 20,000 Level 7 - ドリフトの先駆け * 1988 Mitsubishi Starion ESI-R - 5,000 * 1985 Toyota Sprinter Trueno GT Apex - 6,000 * 1992 Nissan Silvia CLUB K s - 6,000 Level 8 - トラックの王者 * 1969 Shelby GT500 428CJ - 110,000 * 1971 Ford Mustang Mach 1 - 40,000 * 1973 Ford XB Falcon GT - 50,000 Level 9 - アメリカン マッスルの神髄 * 1970 Dodge Coronet Super Bee - 250,000(The American Muscle Car Pack) * 1969 Oldsmobile Hurst/Olds 442 - 40,000 * 1970 Chevrolet Chevelle SS-454 - 48,000 * 1969 Pontiac GTO Judge - 44,000 * 1971 Plymouth GTX 426 HEMI - 125,000(The American Muscle Car Pack) Level 10 - 新鮮なデザイン * 2010 Alfa Romeo Giulietta Quadrifoglio Verde - 36,000(Pre Order) * 2010 Peugeot RCZ - 34,000 * 2009 Volkswagen Scirocco GT - 32,000 * 2010 Mazda Mazdaspeed 3 - 17,000 * 2011 Mini John Cooper Works Clubman - ?(Pre Order) Level 11 - 歴史的なラリー アイコン * 1980 Renault 5 Turbo - 38,000 * 1992 Ford Escort RS Cosworth - 24,000 * 1992 Lancia Delta Integrale EVO - 22,000 * 1994 Toyota Celica GT-Four ST205 - 9,000 * 1982 Lancia 037 Stradale - 240,000 Level 12 - 初期ツーリングカー * 1987 Ford Sierra Cosworth RS500 - 52,000 * 1991 BMW M3 - 16,000 * 1990 Mercedes-Benz 190E 2.5-16 Evolution II - 26,000 Level 13 - スポーツ オフローダー * 2008 Volkswagen Touareg R50 - 65,000 * 2008 Land Rover Rage Rover Supercharged - 68,000 * 2009 Audi Q7 V12 TDI - 100,000 * 2009 Jeep Grand Cherokee SRT8 - 36,000 * 2006 Dodge Ram SRT10 - 24,000 Level 14 - 上級チューナー * 1995 Toyota MR2 GT - 7,000 * 1995 Mitsubishi Eclipse GSX - 6,000 * 2000 Honda Integra Type-R - 8,000 * 2000 Nissan Silvia Spec-R - 16,000 * 1997 Honda Civic Type R - 9,000 Level 15 - アメリカン ドラッグ レーサー * 1971 Plymouth Cuda 426 HEMI - 120,000 * 1967 Chevrolet Corvette Stingray 427 - 90,000 * 1967 Dodge Cornet W023 - 180,000 * 1968 Dodge Dart HEMI Super Stock - 350,000(The American Muscle Car Pack) * 1964 Ford Fairlane Thunderbolt - 200,000(The American Muscle Car Pack) Level 16 - イタリアン マッスル * 1968 Ferrari 365 GTB/4 - 270,000 * 1967 Lamborghini Miura P400 - 400,000 * 1971 De Tomaso Pantera - 45,000 Level 17 - フェザー級 * 2004 Opel Speedster Turbo - 35,000 * 2005 Lotus Elise 111S - 21,000 * 2004 Vauxhall VX220 Turbo - 20,000 Level 18 - 10年越しのライバル * 2011 Subaru Impreza WRX STI - 32,000(Pre Order) * 1999 Mitsubishi Lancer Evolution VI GSR - 12,000 * 2008 Mitsubishi Lancer Evolution X GSR - 29,000 * 2008 Subaru Impreza WRX STI - 25,000 * 1998 Subaru Impreza 22B STi - 35,000 Level 19 - 究極のホット ハッチ * 2010 SEAT Leon CUPRA R - 24,000 * 2010 Honda Mugen Civic Type-R 3D - 55,000 * 2010 Volkswagen Golf R - 42,000 * 2009 Ford Focus RS - 38,000 * 2010 Renault Megane RS 250 - 29,000 Level 20 - 街道のスペシャリスト * 1997 Nissan Skyline GT-R V-Spec - 18,000 * 1992 Honda NSX-R - 90,000 * 1998 Toyota Supra RZ - 28,000 * 1997 Mazda RX-7 - 18,000 * 1997 Mitsubishi GTO - 8,000 Level 21 - モダン アメリカン マッスル * 2009 Dodge Challenger SRT8 - 38,000 * 2010 Ford Shelby GT500 - 48,000 * 2010 Chevrolet Camaro SS - 36,000 * 2012 Dodge Charger SRT8 - 38,000(November Speed Pack) Level 22 - モダン スポーツ セダン * 2009 Lexus IS F - 51,000 * 2010 Audi S4 - 46,000 * 2010 Mercedes-Benz C63 AMG - 60,000 * 2009 Holden HSV w427 - 110,000 Level 23 - モダン スポーツ クーペ * 2010 Chevrolet Corvette Grand Sport - 55,000 * 2010 Nissan 370Z - 34,000 * 2008 BMW M3 - 52,000 * 2007 Audi S5 - 42,000 * 2010 Mercedes-Benz SLK 55 AMG - 58,000 Level 24 - 高級スポーツサルーン * 2012 BMW M5 - 90,000 * 2009 Cadillac CTS-V - 58,000 * 2010 Mercedes-Benz E 63 AMG - 100,000 * 2009 Audi RS 6 - 140,000 * 2010 Jaguar XFR - 80,000 Level 25 - 1980年代のピンナップ * 1984 Ferrari GTO - 320,000 * 1988 Lamborghini Countach LP5000 QV - 150,000 Level 26 - 忘れ難いスタイル * 2010 Morgan Aero SuperSports - 160,000 * 2005 TVR Sagaris - 56,000 * 2010 Spyker C8 Laviolette LM85 - 250,000 Level 27 - 高級ラグジュアリークーペ * 2010 BMW M6 Coupe - 95,000 * 2008 Aston Martin DBS - 250,000 * 2010 Bentley Continental Supersports - 250,000 * 2010 Mercedes CL 65 AMG - 200,000 Level 28 - レース実証済みのテクノロジー * 2003 Dodge Viper SRT-10 - 42,000 * 2005 Aston Martin DB9 Coupe - 130,000 * 2004 Ferrari F430 - 150,000 * 2006 Chevrolet Corvette Z06 - 48,000 * 2005 Ford GT - 150,000 Level 29 - スーパー スポーツ クーペ * 2009 Jaguar XKR-S - 100,000 * 2010 Aston Martin V12 Vantage - 270,000 * 2009 Mercedes SL 65 AMG Black Series - 280,000 Level 30 - ル マンの伝説 * 1965 Shelby Cobra Daytona Coupe - 5,000,000 * 1966 Ford GT40 MkII - 1,500,000 * 1967 Ferrari 330 P4 - 9,000,000 Level 31 - ハイパーカーのパイオニア * 1992 Bugatti EB110 SS - 300,000 * 1993 McLaren F1 - 3,000,000 * 1995 Ferrari F50 - 400,000 * 1993 Jaguar XJ220 - 180,000 Level 32 - リングの王者 * 2008 Dodge Viper SRT10 ACR - 100,000 * 2010 Nissan GT-R SpecV - 150,000 * 2009 Chevrolet Corvette ZR1 - 100,000 Level 33 - アイコニック コンセプト * 2009 Mercedes-Benz SLR Stirling Moss - 1,000,000 * 2006 Lamborghini Miura Concept - 420,000 * 2010 Saleen S5S Raptor - 180,000 Level 34 - 究極のGT * 2010 Audi R8 5.2 FSI Quattro - 150,000 * 2005 Lamborghini Gallardo - 110,000 * 2011 RUF Rt 12 S - 270,000 * 2010 Ferrari 458 Italia - 240,000 * 2011 McLaren MP4-12C - 220,000 Level 35 - ブティック スーパーカー * 2010 Spada Vetture Sport Codatronca TS - 400,000 * 2010 Rossion Q1 - 120,000 * 2010 Wiesmann GT MF5 - 220,000 * 2010 Devon GTX - 300,000 * 2010 Bertone Mantide - 1,000,000 Level 36 - 最上位モデル * 2010 Aston Martin One-77 - 1,800,000 * 2011 Mercedes-Benz SLS AMG - 250,000 * 2011 Ferrari 599 GTO - 370,000 * 2010 Lexus LF-A - 350,000 Level 37 - 公道レースカー * 1997 McLaren F1 GT - 4,000,000 * 1998 Mercedes-Benz AMG Mercedes CLK GTR - 1,200,000 * 1998 Nissan R390 - 1,200,000 * 1999 Lamborghini Diablo GTR - 200,000 Level 38 - モダン GT2 * 2009 Ford #40 Robertson Racing Ford GT Mk7 - 1,000,000 * 2010 BMW #79 Jeff Koons BMWM3 GT2 Art Car - 1,000,000 * 2010 Ferrari #83 Risi Competizione F430GT - 1,000,000 * 2010 Jaguar #33 RSR XKR GT - 1,000,000 * 2011 Ferrari #62 Risi Competizione F458 Italia - 1,000,000(November Speed Pack) Level 39 - ワールド レコード候補 * 2011 Koenigsegg Ager - 1,400,000(Bonus Car Pack) * 2006 Koenigsegg CCX - 550,000 * 2009 Bugatti Veyron 16.4 - 1,400,000 * 2010 SSC Ultimate Aero - 1,000,000 * 2004 Saleen S7 - 320,000 Level 40 - オーストラリア V8 スーパーカー * 2011 Ford #19 Mother Energy Racing Team FG Falcon - 900,000 * 2011 Ford #5 Ford Performance Racing FG Falcon - 900,000 * 2011 Holden #1 Toll Holden Racing Team Commodore VE - 900,000 * 2011 Holden #11 Pepsi Max Crew Commodore VE - 900,000 Level 41 - ブティック ハイパーカー (2012年7月時点) * 2010 Joss JT1 - 400,000 * 2010 Mosler MT900S - 320,000 * 2012 Pagani Huayra - 1,800,000 * 2010 Gumpert Apollo S - 320,000 * 2009 Pagani Zonda Cinque Roadster - 1,500,000 * 2010 Noble M600 - 320,000 (選択肢から消えた) Level 42 - アメリカン ストックカー * 2011 Chevrolet #04 Chevrolet Racing Monte Carlo SS Stock Car - 900,000 * 2011 Ford #05 Ford Racing Fusion Stock Car - 900,000 Level 43 - ドイツ ツーリングカー * 2004 Audi #8 Audi ABT TT-R - 1,200,000 * 2011 Audi #04 Audi A4 Touring Car - 1,200,000 * 2008 Mercedes-Benz Mercedes-AMG C-Class Touring Car - 1,200,000 * 2003 Opel #5 OPC TEAM PHOENIX Astra V8 - 1,200,000 Level 44 - 初期 GT1 * 1998 Nissan #32 NISSAN R390 GT1 - 1,500,000 * 2000 Dodge #91 Team Oreca Dodge Viper GTS-R - 1,100,000 * 1997 McLaren #43 Team BMW McLaren F1 GTR - 1,500,000 * 2003 Saleen #2 Konrad Motorsports S7R - 1,500,000 * 2005 Maserati #15 JMB Racing MC12 - 1,100,000 Level 45 - Super GT500 * 2005 Toyota #6 EXXON Superflo Supra - 1,500,000 * 2005 Honda #18 TAKATA DOME NSX - 1,500,000 * 2010 Nissan #12 CALSONIC IMPUL GT-R - 1,500,000 * 2010 Lexus #1 PETRONAS TOM S SC430 - 1,500,000 * 2003 Nissan #12 CALSONIC SKYLINE - 1,500,000 Level 46 - GT1 ライバル * 2008 Aston Martin #009 Aston Martin Racing DBR9 - 1,100,000 * 2006 Chevrolet #4 Corvette Racing C6.R - 1,100,000 * 2006 Aston Martin #007 Aston Martin Racing DBR 9 - 1,100,000 * 2004 Chevrolet #3 Corvette Racing C5.R - 1,100,000 Level 47 - 究極のハイパーカー * 2008 Koenigsegg CCGT - 1,500,000 * 2010 Pagani Zonda R - 1,700,000 * 2011 Radical SR8 RX - 300,000 * 2008 Mazda Furai - 1,000,000 * 2011 Bugatti Veyron Super Sport - 2,200,000(VIP Car Pack) Level 48 - 初期 LMP1 * 1999 Toyota #3 Toyota Motorsports GT-ONE TSO20 - 2,200,000 * 1999 BMW #15 BMW V12 LMR - 2,200,000 * 2006 Audi #2 Audi Sport North America R8 - 2,200,000 * 2003 Bentley #7 Team Bentley Speed 8 - 2,200,000 * 2003 Panoz #11 JML Team Panoz LMP-01 - 2,200,000 Level 49 - モダン LMP2 * 2010 Mazda #16 Dyson Racing B09/86 - 2,000,000 * 2010 Chevrolet #99 Green Earth Team Gunnar Oreca FLM09 - 2,000,000 * 2008 Acura #15 Lowe s Fernandez ARX-01b - 2,000,000 Level 50 - モダン LMP1 * 2009 Acura #66 de Ferran Motorsport Jim Hall Tribute ARX-02a - 2,500,000 * 2011 Aston Martin #6 Muscle Milk Aston Martin Lola - 2,500,000 * 2011 #2 Audi Sport Team Joest R15++ TDI - 2,500,000 (November Speed Pack) * 2009 Audi #2 Audi Sport Team Joest R15 TDI - 2,500,000 * 2011 Peugeot #10 Matmut-Oreca 908 - 2,500,000 コメント Lv19 究極のホットハッチですが、November pack導入後だと2010 SEAT Leon CUPRA R, 2010 Renault Megane RS 250が2013 Focus S(32000)T, 2011 Audi RS3 Sportback(60000)に置き換わるようです。 -- (名無しさん) 2011-11-08 16 41 56 Lv10に2013 Hyundai Veloster Turboが追加されてた、プレオーダーは持ってないので置き換えがあったかはわかんないけど。 -- (名無しさん) 2012-01-21 00 33 50 Level 38 - モダン GT2、『January Jalopnik Car Pack』『November Speed Pack』を導入した状態では、『2011 Lamborghini Gallardo # 08 West Yokohama LP560-4』『2011 Risi Competizione F458 Italia』『Ford #40』『BMW #79』『Ferrari #62』となり、『2010 Jaguar #33 RSR XKR GT』が無くなります。（『January Jalopnik Car Pack』のみの場合は『Jaguar #33』が残るのかもしれません、どなたか機会があれば確認してください） -- (名無しさん) 2012-01-22 21 51 59 Level50 モダンLMP1で『February ALMS Pack』導入後にAcura #66 de Ferran Motorsport Jim Hall Tribute ARX-02aが#2 Audi Sport North America R18 TDIに置き換わっているのを確認しました。 -- (名無しさん) 2012-03-03 11 13 32 Level 27 - 高級ラグジュアリークーペ、『January Jalopnik Car Pack』導入時は『2011 Audi RS 5』が追加されています。 -- (名無しさん) 2012-09-09 21 59 21 名前 コメント すべてのコメントを見る
https://w.atwiki.jp/dslbookwip/pages/22.html
Context Variable(コンテキスト変数) 動作原理 いつ使うか 例 Iniファイルの読み込み(C#) 原文はこちら： http //martinfowler.com/dslwip/ContextVariable.html 原文、翻訳共に作成中です。 Context Variable(コンテキスト変数) パース過程で必要となる変数を保持する 複数のアイテムから構成されるリストをパースしているとします。それぞれのアイテム中から何らかのデータをキャプチャしているとしましょう。アイテム中のデータそれぞれは独立してキャプチャできるとして、今キャプチャしているデータを含むアイテム自体の情報も知っている必要があります。 Context Variable(文脈変数）は現在処理中のアイテムを変数に保持し、次のアイテムに進んだら順次再割り当てをすることで、この目的を達成します。 動作原理 パース処理中、currentItemのような変数を用意し、次のアイテムに移るごとに定期的に更新しているとしたら、それはContext Variableと呼ぶことができます。 Context VariableはSemantic Modelオブジェクトでも、何らかのビルダーでも構わないでしょう。Semantic Modelはより直接的ですが、使えるのはパース処理中にSemantic Modelの全プロパティが変更可能である時に限ります。そうでない場合は、Construction Builderのように、何らかのビルダーを使って情報を集め、最後にSemantic Modelを作り上げるのが良いでしょう。 いつ使うか パース処理中に何らかのコンテキストを保持する必要性が生じることは良くあり、Context Variableはそのような場合の明確な候補です。Context Variableは簡単に導入できます。 しかし、Context Variableが問題となる場合があります。それは、多用しすぎてしまう場合です。Context Variableは元来、可変な状態なので、きっちり追跡しておかないとバグの温床になり得ます。というのも、Context Variableは然るべき時に更新するのを忘れやすいので、そデバッグがとても難しくなることがあります。通常の防衛策はContext Variableを必要とするパース処理を小さく保つようににパース処理を構成することです。私自身はContext Variable自体が邪悪なものだとは思っていませんが、それでもできるだけContext Variableが必要とならないテクニックを使うことを好みます（この本の中で、至る所で私のこの考えを目撃することになるでしょう）。 例 Iniファイルの読み込み(C#) ここでは、Context Variableがどういうものか示すために、至極簡単な例であるiniファイルのパース処理を取りげることにします。iniファイルフォーマットは例としては良い素材です。Windowsではより改善されたレジストリがあります。なのでiniファイルは古めかしいものですが、それでも幾つかのプロパティを含むシンプルなリストを扱うには可読性が高く、軽いフォーマットです。代替としてのXMLやYAMLはより複雑な構造を扱えます。それでも必要としているものがシンプルなiniファイルで十分であるような場合、iniファイルは今でも合理的な選択肢です。 例に使うのは、プロジェクトのコードが幾つかあり、各プロジェクトに幾つかのプロパティが含まれているiniファイルを取り上げます。 [intro] name = Introduction lead = Martin [type-transmog] name = Type Transmogrification lead=Neal #line comment [lang] #group comment name = Language Background Advice lead = Revecca # item comment iniファイルのフォーマットには標準がありませんが、基本となる要素はプロパティの一群で、それぞれ各セクションに割り当てられています。このiniファイルでは各セクションはプロジェクトのコードです。 このiniファイルのSemantic Modelは取るに足らないものです。 class Project... class Project { public string Code {get; set;} public string Name {get; set;} public srting Lead {get; set;} iniファイルフォーマットはDelimiter Directed Translationを使って簡単に読み込むことができます。パーサの基本的な構造はスクリプト(訳注 ここではiniファイルのことかと）を行分割し、各行をパースしていくという通常のアプローチです。 class ProjectParser private TextReader input; private List Project result = new List Project (); public ProjectParser(TextReaer input) { this.input = input; } public List Project Run(){ string line; while((line = input.ReadLine()) != null){ parseLine(line); } return result; } 最初の節では各行のパーサは空白とコメントを処理します。 class ProjecrParser... private void parseLine(string s) { var line = removeComments(s); if (isBlank(line)) return; else if (isSection(line)) parseSection(line); else if (isProperty(line)) parseProperty(line); else throw new ArgumentException("Unable to parse + line") } private strin removeComments(string s){ return s.Split( # )[0]; } private bool isBlank(string line){ return Regex.IsMatch(line , @"^\s*$"); } Context VariableであるcurrentProject変数はその時点で割り当てられているセクションを保持するために使います。 class ProjectParser... private bool isSection(string line){ return Regex.IsMatch(line @"^\s\["); } private void parseSection(sting line) { var code = new RegEx(@"\[(.*)\]").Match(line).Groups[1].value; currentProject = new Project {Code = code}; result.Add(currentProject); } private Project currentProject; そして、Context Variable(currentPojectメンバ)をプロパティをパースするときに使います。 class ProjectParser... private bool isProperty(string line){ return Regex.IsMatch(line, @"=") } private void parseProperty(string line) { var tokens = extractPropertyTokens(line); setProjectProperty(tokens[0], tokens[1]); } private sting[] extracePropertyTokens(string line){ char[] sep = { = }; var tokens = line.Split(sep,2); if (tokens.Lengs 2) throw new ArgumentException("unable to split"); for (var i = 0; i tokens.Length; i++) tokens[i] = tokens[i].Trim(); return tokens; } private void setProjectProperty(string name, string value){ var proj = typeof(Project); var prop = proj.GetProperty(capitalize(name)); if (prop == null) throw new ArgumentException("Unable to find property " + name); prop.SetValue(currentProject, value, null); } private string capitalize(string s) { return s.Substring(0,1).ToUpper() + s.SubString(1).ToLower(); } リフレクションを使えばコードはより複雑になりますが、Semantic Modelにプロパティを追加した時にパーサのコードを変更しなくても良くなります。 名前 コメント
https://w.atwiki.jp/forzahorizon/pages/2.html
メニュー トップページ よくある質問 質問箱 不具合情報 発売前情報 公式イベント 公式デザインコンテスト 公式フォトコンテスト 当wikiは一部のページを除き誰でも新規作成・編集が可能です。メンバー参加は自動承認となっています。 プレイヤー交流場所 カークラブ 共有タグ 画像共有 ペイントBBS データ 収録車種 企業別車種一覧 DLC配信車種一覧 ギフトカー ユニコーンカー リワードカー 掘り出し物 カープライズ その他 収録曲 +地図・掘り出し物他（英語） 全体図 BMW M1 Mercedes-Benz 300SL Gullwing Coupe Bugatti EB110 SS Aston Martin DB5 Vantage Plymouth Cuda 426 Hemi Jaguar D-Type Shelby Cobra Daytona Aston Martin DBR1 Ferrari 250 Testa Rossa CO-OPチャレンジ主要起点MAP 拡張パック フォト カスタマイズ パーツ選び（clicker.com） オンライン関連 マルチプレイ ライバル 実績一覧 アンケート 体験版レビュー ラリー拡張パックレビュー リンク 関連サイト 最新の10件 取得中です。 @WeArePlayground からのツイート Tot - Tod - Yes - ここを編集
https://w.atwiki.jp/nfsuc2ch/pages/13.html
199 ：名無しさん＠お腹いっぱい。：2008/11/29(土) 19 02 55 ID JMXKT0Fs せっかくなのでNFC UCに登場する車のリストを載せておくよ(´・ω・｀) PS3・Xb360・PC版 2006 Aston Martin DB9 2008 Audi R8 (Exclusive) 2006 Audi RS 4 (Exclusive) 2009 Audi S5 (Exclusive) 2007 Audi TT 3.2 quattro (Exclusive) 2003 BMW M3 (E46) (Exclusive) 2008 BMW M3 (E92) (Exclusive) 2008 BMW M6 (E63) (Exclusive) 2006 BMW Z4 M Coupe (Collector s Edition DLC; Exclusive) 2006 Bugatti Veyron 16.4 (Exclusive) 2006 Cadillac CTS-V (Exclusive) 1967 Chevrolet Camaro SS 396 2008 Chevrolet Camaro Concept 1970 Chevrolet Chevelle SS 454 1967 Chevrolet Corvette Stingray (C2) (Exclusive) 2006 Chevrolet Corvette Z06 (C6) 1971 Dodge Challenger 2006 Dodge Challenger Concept (Collector s Edition DLC) 1969 Dodge Charger R/T 440 2007 Dodge Charger SRT8 Super Bee 2006 Dodge Viper SRT-10 (w/ 08 hood) 1996 Ford Escort RS Cosworth (Exclusive) 2006 Ford Focus ST (Exclusive) 2006 Ford GT 2006 Ford Mustang GT 200 ：199：2008/11/29(土) 19 03 57 ID JMXKT0Fs 2006 Koenigsegg CCX (Collector s Edition DLC) 2009 Lamborghini Gallardo LP560-4 (Exclusive) 2006 Lamborghini Murcielago LP640 2008 Lexus IS-F (Exclusive) 2006 Lotus Elise 1995 Mazda RX-7 2006 Mazda RX-8 2006 Mazdaspeed 3 1994 McLaren F1 (Exclusive) 2008 Mercedes CLS 63 AMG (Exclusive) 2004 Mercedes SL 65 AMG (R230) (Collector s Edition DLC) 2007 Mercedes SLR McLaren 722 Edition (Exclusive) 2006 Mitsubishi Lancer Evolution IX MR 2008 Mitsubishi Lancer Evolution X (Exclusive) 1989 Nissan 240SX (S13) 2009 Nissan 370Z (Z34) 2007 Nissan GT-R (R35) (Exclusive) 2000 Nissan Silvia (S15) (Exclusive) 1999 Nissan Skyline GT-R V-spec (R34) 2006 Pagani Zonda F 1970 Plymouth Barracuda Hemi 440 1965 Pontiac GTO (Exclusive) 2006 Pontiac Solstice GXP (Exclusive) 2008 Porsche 911 GT2 (997) 2006 Porsche 911 GT3 RS (997) (Exclusive) 2006 Porsche 911 Turbo (997) 2005 Porsche Carrera GT 2007 Porsche Cayman S (Collector s Edition DLC) 2008 Renault Megane Coupe (Exclusive) 1967 Shelby GT500 2008 Shelby GT500KR (Exclusive) 1998 Toyota Supra Twin Turbo (Mk4) 2006 Volkswagen Golf R32 (Mk V) 2008 Volkswagen Scirocco (Exclusive) 201 ：199：2008/11/29(土) 19 04 53 ID JMXKT0Fs PS2版 2006 Aston Martin DB9 1967 Chevrolet Camaro SS 396 2008 Chevrolet Camaro Concept 2006 Chevrolet Corvette Z06 (C6) 2005 Chrysler 300C SRT8 (Exclusive) 1971 Dodge Challenger 2006 Dodge Challenger Concept 1969 Dodge Charger R/T 440 2007 Dodge Charger SRT8 2006 Dodge Viper SRT-10 2006 Ford GT 2006 Ford Mustang GT 2006 Infiniti G35 (Exclusive) 2006 Koenigsegg CCX 2004 Lamborghini Gallardo (standard model) (Exclusive) 2006 Lamborghini Murcielago LP640 2006 Lotus Elise 1995 Mazda RX-7 2006 Mazda RX-8 2006 Mazdaspeed 3 2004 Mercedes CLK 500 (W209) (Exclusive) 2004 Mercedes SL 65 AMG (R230) 2006 Mercedes SLR McLaren (standard model) (Exclusive) 2006 Mitsubishi Eclipse (4G) (Exclusive) 2006 Mitsubishi Lancer Evolution IX MR 1989 Nissan 240SX (S13) 2006 Nissan 350Z (Z33) (Exclusive) 2009 Nissan 370Z (Z34) 1999 Nissan Skyline GT-R V-spec (R34) 2006 Pagani Zonda F 1970 Plymouth Barracuda Hemi 440 2008 Porsche 911 GT2 (997) 2006 Porsche 911 Turbo (997) 2005 Porsche Carrera GT 2007 Porsche Cayman S 2004 Renault Clio V6 (Mk II) (Exclusive) 1967 Shelby GT500 1998 Toyota Supra (Mk4) 2006 Volkswagen Golf R32 (Mk V) 202 ：199：2008/11/29(土) 19 05 48 ID JMXKT0Fs Other Spotted Cars Audi TT (1st-gen) Dodge Viper (1st/2nd-gen) Porsche 911 GT3 (997) Shelby Terlingua Racing Team V-6 Mustang DS版(日本未発売) 1967 Chevrolet Camaro SS 396 1969 Dodge Charger R/T 440 2006 Dodge Challenger Concept 2006 Dodge Viper SRT-10 2006 Ford GT 2006 Ford Mustang GT 2006 Infiniti G35 (Exclusive) 2004 Lamborghini Gallardo (standard model) (Exclusive) 2006 Lamborghini Murcielago LP640 1995 Mazda RX-7 2004 Mercedes SL 65 AMG (R230) 2006 Mitsubishi Lancer Evolution IX MR 2006 Nissan 350Z (Z33) (Exclusive) 2009 Nissan 370Z (Z34) (キャリアモードで購入不可) 2006 Pagani Zonda F 2008 Porsche 911 GT2 (997) 2005 Porsche Carrera GT
https://w.atwiki.jp/dslbookwip/pages/12.html
このページはhttp //martinfowler.com/dslwip/Intro.htmlからの引用です | DSL-WIP Home | WORK-IN-PROGRESS - this material is still under development An Introductory Example Last significant update 06 Aug 07 Contents Miss Grant s Controller The State Machine Model Programming the Controller with a Domain Specific Language Languages and Model Using Code-Generation Using Language Workbenches Visualization Picking up this book, you may be asking yourself such questions as what is a DSL , how does it fit in with my usual development work and why would I find such a thing useful ? This chapter begins by looking at these questions. I ll talk about what a DSL is, the various types of DSL, the reasons to use a DSL, and the broader topic of language processing. At this stage I won t talk about how the various styles of DSL work - we ll get into that later. Miss Grant s Controller As is usual for me, I ll base this discussion on an example, as I find that a concrete example usually makes it easier to follow an abstract topic like this. Let s imagine a company that makes systems to control access to secret compartments. Their customers are people who are bored with numeric keypads and security codes, instead preferring something recalling bad movies set in gothic castles. So Miss Grant has a secret compartment in her bedroom that is normally locked and concealed. To open it she has to close the door, open the second draw in her chest, turn her bedside light on - and then the secret panel is unlocked for her to open. Mr G has the same basic system for a panel in his bedroom. He has to open his bathroom door and turn on the main light which allows him to open the panel. The panel reveals a safe, but it has an overriding lock that cannot be opened unless he turns his light off and on again. Mr C has a compartment in his office, he has to close his main door, take a picture off the wall, turn his desklight on three times, open the top draw of his filing cabinet, turn the desklight off - and then the panel s unlocked. If he forgets to turn the desklight off, he wants an alarm to sound. Although this example is deliberately whimsical, the underlying point isn t that unusual. What we have is a family of systems which share most components and behaviors, but have some important differences. In this case we have some kind of controller software which communicates with various devices around the room. The variability is in the sequence of actions that can be carried out and the actions that the software does as a result of these sequences. We want to arrange things so that the company can install a new system with the minimum of effort, so it must be easy for them to program the sequence of actions into the controller. Looking at their many customers they realize there is a common theme to the way they behave. The various devices send events as they are manipulated. The system reacts differently to events depending on the recent sequence of events. This style of thinking about behavior is that of a state machine. Thus it makes sense to build a model of a state machine that can be programmed for individual customers at each site. That way the general behavior can be resued for each customer and setting up a new customer just means writing the specific things for each case. The software is written in java, running on a job lot of toasters they picked up from a failed dot com. The State Machine Model There are many varieties of state machine models around, this one is simple, and with a little twist for the this particular case. There are frameworks out there to run state machines, but we can do with something much simpler that s more suited to this particular domain. By doing this we give up some power for an easier job working with it. This issue isn t really part of the DSL discussion so I won t explore it further. To help understand how the state machine model works, let s take Miss Grant s system. Figure 1 State diagram for Miss Grant The system has a controller that receives events and commands from the various devices scattered around. Each event and command has a four letter code that s the actual signal sent through the communication channels. I want to refer to these in the controller code with symbolic names, so I create event and command classes with a code and a name. I keep them as separate classes (with a superclass) as they play different roles in the controller code. class AbstractEvent... private String name, code; public AbstractEvent(String name, String code) { this.name = name; this.code = code; } public String getCode() { return code;} public String getName() { return name;} public class Command extends AbstractEvent public class Event extends AbstractEvent Figure 2 Class diagram of the state machine framework [TBD Add reset event association to class diagram] The key to the structure is that state class. Each state class keeps track of the events and commands. class State... private String name; private List Command actions = new ArrayList Command (); private Map String, Transition transitions = new HashMap String, Transition (); public void addTransition(Event event, State targetState) { transitions.put(event.getCode(), new Transition(this, event, targetState)); } class Transition... private final State source, target; private final Event trigger; public Transition(State source, Event trigger, State target) { this.source = source; this.target = target; this.trigger = trigger; } public State getSource() {return source;} public State getTarget() {return target;} public Event getTrigger() {return trigger;} public String getEventCode() {return trigger.getCode();} The state machine holds on to its start state. class StateMachine... private State start; public StateMachine(State start) { this.start = start; } Any other states in the machine are then those that are reachable from this state. class StateMachine... public Collection State getStates() { List State result = new ArrayList State (); gatherForwards(result, start); return result; } private void gatherForwards(Collection State result, State start) { if (start == null) return; if (result.contains(start)) return; else { result.add(start); for (State next start.getAllTargets()) { gatherForwards(result, next); } return; } } class State... Collection State getAllTargets() { List State result = new ArrayList State (); for (Transition t transitions.values()) result.add(t.getTarget()); return result; } There is one particular wrinkle to this problem. These controllers have a particular nature to them in that most of the time they are in their start state, which is effectively an idle state. There are events that advance the state machine, and there are events that take you back to that start state. For this case opening the door always takes you back to the start. So I let the machine keep track of reset events. class StateMachine... private List Event resetEvents = new ArrayList Event (); public void addResetEvents(Event... events) { for (Event e events) resetEvents.add(e); } I don t need to have a separate structure for reset events here. I could handle this by simply declaring extra transitions on the state machine like this class StateMachine... private void addResetEvent_byAddingTransitions(Event e) { for (State s getStates()) if (!s.hasTransition(e.getCode())) s.addTransition(e, start); } I prefer explicit reset events on the machine becuase that better expresses the intention of what I m trying to do. While it does complicate the machine a bit, it keeps the clarity of my intention of how a general machine is supposed to work, as well as keeping the intention of how a particular machine is defined. With the structure out of the way, now lets move on to the behavior. As it turns out, it s really quite simple. The controller has a handle method that takes the event code it receives from the device. class Controller... private State currentState; private StateMachine machine; public CommandChannel getCommandChannel() { return commandsChannel; } protected CommandChannel commandsChannel; public void handle(String eventCode) { if (currentState.hasTransition(eventCode)) transitionTo(currentState.targetState(eventCode)); else if (machine.isResetEvent(eventCode)) transitionTo(machine.getStart()); // ignore unknown events } private void transitionTo(State target) { currentState = target; currentState.executeActions(commandsChannel); } class State... public boolean hasTransition(String eventCode) { return transitions.containsKey(eventCode); } public State targetState(String eventCode) { return transitions.get(eventCode).getTarget(); } public void executeActions(CommandChannel commandsChannel) { for (Command c actions) commandsChannel.send(c.getCode()); } class StateMachine... public boolean isResetEvent(String eventCode) { return resetEventCodes().contains(eventCode); } private List String resetEventCodes() { List String result = new ArrayList String (); for (Event e resetEvents) result.add(e.getCode()); return result; } It ignores any events that are not registered on the state. For any events that are recognized, it transitions to the target state and executes any commands defined on that target state. Programming the Controller with a Domain Specific Language Now I ve implemented the state machine model, I can now program Miss Grant s controller like this. Event doorClosed = new Event( doorClosed , D1CL ); Event drawOpened = new Event( drawOpened , D2OP ); Event lightOn = new Event( lightOn , L1ON ); Event doorOpened = new Event( doorOpened , D1OP ); Event panelClosed = new Event( panelClosed , PNCL ); Command unlockPanelCmd = new Command( unlockPanel , PNUL ); Command lockPanelCmd = new Command( lockPanel , PNLK ); Command lockDoorCmd = new Command( lockDoor , D1LK ); Command unlockDoorCmd = new Command( unlockDoor , D1UL ); State idle = new State( idle ); State activeState = new State( active ); State waitingForLightState = new State( waitingForLight ); State waitingForDrawState = new State( waitingForDraw ); State unlockedPanelState = new State( unlockedPanel ); StateMachine machine = new StateMachine(idle); idle.addTransition(doorClosed, activeState); idle.addAction(unlockDoorCmd); idle.addAction(lockPanelCmd); activeState.addTransition(drawOpened, waitingForLightState); activeState.addTransition(lightOn, waitingForDrawState); waitingForLightState.addTransition(lightOn, unlockedPanelState); waitingForDrawState.addTransition(drawOpened, unlockedPanelState); unlockedPanelState.addAction(unlockPanelCmd); unlockedPanelState.addAction(lockDoorCmd); unlockedPanelState.addTransition(panelClosed, idle); machine.addResetEvents(doorOpened); I look at this last bit of code as quite different in nature to the previous peices. The earlier code described how to build the state machine model, this last bit of code is about how to configure that model for one particular controller. You often see divisions like this. On the one hand is library, framework, or component implementation code; on the other is configuration or component assembly code. Essentially it is the separation of common code from variable code. We structure the common code in a set of components that we then configure for different purposes. Here is another way of representing that configuration code. stateMachine start = idle event name= doorClosed code= D1CL / event name= drawOpened code= D2OP / event name= lightOn code= L1ON / event name= doorOpened code= D1OP / event name= panelClosed code= PNCL / command name= unlockPanel code= PNUL / command name= lockPanel code= PNLK / command name= lockDoor code= D1LK / command name= unlockDoor code= D1UL / state name= idle transition event= doorClosed target= active / action command= unlockDoor / action command= lockPanel / /state state name= active transition event= drawOpened target= waitingForLight / transition event= lightOn target= waitingForDraw / /state state name= waitingForLight transition event= lightOn target= unlockedPanel / /state state name= waitingForDraw transition event= drawOpened target= unlockedPanel / /state state name= unlockedPanel action command= unlockPanel / action command= lockDoor / transition event= panelClosed target= idle / /state resetEvent name = doorOpened / /stateMachine This style of representation should look familiar to most readers, I ve expressed it as an XML file. There are several advantages to doing it this way. One obvious reason is that now we don t have to compile a separate java program for each controller we put into the field - instead we can just compile the state machine components plus an appropritate parser into a common jar, and ship the xml file to be read when the machine starts up. Any changes to the behavior of the controller can be done without having to distribute a new jar. (We do, of course, pay for this in that any mistakes in the syntax of the configuration can only be detected at run time.) A second advantage is in the expressiveness of the file itself. We no longer need to worry about the details of making the various connections through variables. Instead we have a more declarative approach that in many ways reads much more clearly. We re also limited in that we can only express configuration in this file - limitations like this often are helpful because they can reduce the chances for people making mistakes in the component assembly code. These advantages are why so many frameworks in Java and C# are configured with XML configuration files. These days it sometimes feels that you re doing more programming with XML than you are with main programming language. Here s another version of the configuration code. events doorClosed D1CL drawOpened D2OP lightOn L1ON doorOpened D1OP panelClosed PNCL end resetEvents doorOpened end commands unlockPanel PNUL lockPanel PNLK lockDoor D1LK unlockDoor D1UL end state idle actions {unlockDoor lockPanel} doorClosed = active end state active drawOpened = waitingForLight lightOn = waitingForDraw end state waitingForLight lightOn = unlockedPanel end state waitingForDraw drawOpened = unlockedPanel end state unlockedPanel actions {unlockPanel lockDoor} panelClosed = idle end This is code, although not in a syntax that s familiar to you. In fact it s a custom syntax that I made up for this example. I think it s a syntax that s easier to write, and above all easier to read, than the XML syntax. It s terser and avoids a lot of the quoting and noise characters that the XML suffers from. You probably wouldn t have done it exactly the same way, but the point is that you can construct whatever syntax you and your team prefers. You can still load it in at runtime (like the XML) but you don t have to (as you don t with the XML) if you want it at compile time. This language is a Domain Specific Language, and shares many of the characteristics of DSLs. Firstly it s suitable only for a very narrow purpose - it can t do anything other than configure this particular kind of state machine. As a result the DSL is very simple - there s no facility for control structures or anything else. It s not even Turing complete. You couldn t write a whole application in this language - all you can do is describe one small aspect of an application. As a result the DSL has to be combined with other languages to get anything done. But the simplicity of the DSL means it s easy to edit and process. Now look again at the XML representation. Is this a DSL? I would argue that it is. It s wrapped in an XML carrier syntax - but it s still a DSL. This example thus raises a design issue - is it better to have custom syntax for a DSL or an XML syntax? The XML syntax can be easier to parse since people are so familiar with parsing XML. (As it happened for this example it took me the about the same amount of time to write the parser for the custom syntax as it did for the XML.) I d contend that the custom syntax is much easier to read, at least in this case. But however you view this choice the core trade-offs around DSLs are the same. Indeed you can argue that most XML configuration files are essentially DSLs. Let s go back a step further, back to the configuration code in Java I showed you earlier - is that a DSL? While you re thinking about that question look at this code. Does this look like a DSL for this problem? event doorClosed, D1CL event drawOpened, D2OP event lightOn, L1ON event doorOpened, D1OP event panelClosed, PNCL command unlockPanel, PNUL command lockPanel, PNLK command lockDoor, D1LK command unlockDoor, D1UL resetEvents doorOpened state idle do actions unlockDoor, lockPanel transitions doorClosed = active end state active do transitions drawOpened = waitingForLight, lightOn = waitingForDraw end state waitingForLight do transitions lightOn = unlockedPanel end state waitingForDraw do transitions drawOpened = unlockedPanel end state unlockedPanel do actions unlockPanel, lockDoor transitions panelClosed = idle end It s a bit noisier than the custom language earlier, but still pretty clear. Readers who have similar language likings to me will probably know that it s Ruby. Ruby gives me a lot of syntactic options that makes for more readable code, so I can make it look very similar to the custom language. Ruby developers would consider this code to be a DSL. I use a subset of the capabilities of Ruby and capture same ideas as our XML and custom syntax. Essentially I m embedding the DSL into ruby, using a subset of ruby as my syntax. To an extent this is more a matter of attitude than of anything else. I m choosing to look at the Ruby code through DSL glasses. But it s a point of view with a long tradition - Lisp programmers often think of creating DSLs inside Lisp. This brings me to pointing out that there are two kinds of textual DSLs which I call external and internal DSLs. AnExternal DSLis a domain specific language represented in a separate language to the main programming language it s working with. This language may be a custom syntax, or it may follow the syntax of another representation (like XML). AnInternal DSLis DSL expressed within the syntax of a general purpose language. It s a stylized use of that language for a domain specific purpose. You may also hear the termembedded DSLas a synonym for internal DSL. Although it is fairly widely used, I avoid this term because you also hear embedded language applied to scripting languages embedded within applications such as VBA in Excel or Scheme in the Gimp. So I use internal DSL to avoid confusion. Now think again about the original java configuration code - is this a DSL? I would argue that it isn t. That code feels like stitching together with an API, while the ruby code above has more the feel of a declarative language. Does this mean you can t do an internal DSL in Java? How about this? public class BasicStateMachine extends StateMachineBuilder { Events doorClosed, drawOpened, lightOn, panelClosed; Commands unlockPanel, lockPanel, lockDoor, unlockDoor; States idle, active, waitingForLight, waitingForDraw, unlockedPanel; ResetEvents doorOpened; protected void defineStateMachine() { doorClosed. code( D1CL ); drawOpened. code( D2OP ); lightOn. code( L1ON ); panelClosed.code( PNCL ); doorOpened. code( D1OP ); unlockPanel.code( PNUL ); lockPanel. code( PNLK ); lockDoor. code( D1LK ); unlockDoor. code( D1UL ); idle .actions(unlockDoor, lockPanel) .transition(doorClosed).to(active) ; active .transition(drawOpened).to(waitingForLight) .transition(lightOn). to(waitingForDraw) ; waitingForLight .transition(lightOn).to(unlockedPanel) ; waitingForDraw .transition(drawOpened).to(unlockedPanel) ; unlockedPanel .actions(unlockPanel, lockDoor) .transition(panelClosed).to(idle) ; } } It s formatted oddly, and uses some unusual programming conventions, but it is valid Java. It s java written in what is these days called a Fluent Interface style. AFluent Interfaceis an API that s designed to read like an internal DSL. This I would call a DSL - although it s more messy than the ruby DSL it still has that declarative flow that a DSL needs. What makes a fluent interface different to a normal API? This is a tough question that I ll spend more time onlater), but it comes down to a rather fuzzy notion of a language-like flow. Given this distinction it s useful to have a name for a non-fluent API - I ll use the termcommand-query API. Languages and Model There s an important inter-relationship here between the various DSLs and the underlying state-machine model. To implement each of these languages I wrote code that translated from expressions in the DSL into calls on the command-query interface of the model. So while I was parsing the custom syntax version and came across commands unlockPanel PNUL I would create a new command object (new Command( unlockPanel , PNUL )) and keep it to one side (in aSymbol Table) so that when I sawactions {unlockPanelI could add it to the appropriate state (usingaddAction). As a result each DSL I ve shown you created the same configuration of objects in the model. The model, as I discussed earlier, is the engine that provides the behavior of the state-machine. So once we have a populated model, we have a running program whose behavior is encoded in the inter-relationships between the objects in that model. This style is often called an Active Object Model, because in order to understand the behavior of the state machine you can t just look at the code, you also have to look at the way object instances are wired together. Of course this is always true to some extent, any program gives different results with different data, but there is a sense of a greater difference here as the presence of the state objects alters the behavior of the system to a significantly greater degree. When people discuss a programming language you often hear them talk about syntax and semantics. The syntax captures the legal expressions of the program, what in the custom syntax DSL is captured by the grammar. The semantics of a program is what it means, that is what it does when it executes. In this case it is the model that defines those semantics - which is why I will refer to it as aSemantic Model. In this example theSemantic Modelis an object model. ASemantic Modelcan also take other forms. It can be a pure data structure with all behavior in separate functions. I would still refer to it as an active model, because the data structure defines the program s behavior. Looking at it from this point of view, the DSL merely acts as a mechanism for expressing how the model is configured. I often refer to a DSL as a thin facade over a framework. Much of the benefits of using this approach comes from the model rather than the DSLs. The fact that I can easily configure a new state machine for a customer is a property of the model, not the DSL. The fact that I can make a change to a controller at run-time, without compiling, is a feature of the model, not the DSL. The fact I m reusing code across multiple installations of controllers is a property of the model, not the DSL. A model provides many benefits without any DSLs present. As a result we use them all the time. We use libraries and frameworks to wisely avoid work. In our own software we construct our own models, building up abstractions that allow us to program faster. Good models, whether published as libraries and frameworks or just serving our own code, can work just fine without any DSL in sight. But DSLs can enhance the the capabilities of a model. The right DSL makes it easier to understand what a particular state machine does. Some DSLs allow you to configure the model at run time. DSLs are thus a useful adjunct to some models. In discussing this example I described a circumstance where the model was built first, and then I layered a DSL over the model to help manipulate it. I described it that way becuase I think that s an easy way to understand how DSLs fit into software development. Although the model-first case is a common one, it isn t the only one. In a different scenario you talk with the domain experts and posit that a state machine approach is something they understand. You then work with the domain experts to create a DSL that they can understand. In this case you build the DSL and model simultaneously. Using Code-Generation In my discussion so far, I process the DSL by populating theSemantic Modeland then execute theSemantic Modelto provide the behavior that I want from the controller. This approach is what s known in language circles as interpretation. When weinterpretsome text, we parse it and immediately produce the result that we want from the program. (Interpret is a tricky word in software circles, since it carries all sorts of connotations for people, however I ll use it strictly to mean this form of immediate execution.) In the language world, the alternative to interpretation is compilation. Withcompilation, we parse some program text and produce an intermediate output, which is then separately processed to provide the behavior we desire. In the context of DSLs the compilation approach is usually referred to ascode-generation. In this case this might mean generating some java code to represent the particular behavior of Miss Grant s controller. Code generation is often awkward in that it often pushes you to an extra compilation. To build your program you have to first compile the state framework and the parser, then run the parser to generate the source code for Miss Grant s controller, then compile that generated code. This makes your build process much more complicated. However an advantage of code generation is that there s no reason why you have to generate code in same programming language that you use for the parser. In this case you can avoid the second compilation step by generating code for a dynamic language such as javascript or jruby. Code generation is also useful when you want to use DSLs with a language platform that doesn t have the tools for DSL support. I ve come across recent projects that generate code for MathCAD, SQL, and COBOL. Many writings on DSLs focus on code-generation, even to the point of making code-generation the primary aim of the exercise. As a result you can find articles and books extolling the virtues of code-generation. In my view, however, code-generation is merely an implementation mechanism, one that isn t actually needed in most cases. Certainly there are plenty of times when you must use code-generation, but there are even more plenty of times when you don t need it. Using code-generation is one case where many people don t use aSemantic Model. In this case you parse the input text and directly produce the generated code. Although this is a common way of working with code-generated DSLs, it isn t one I reccommend for any but the very simplest cases. Using aSemantic Modelallows me to separate the parsing, the execution semantics, and the code generation into separate problems. This separation makes the whole exercise a lot simpler. It also allows me to change my mind. I can change my DSL from an internal to an external DSL (say) without altering my code-generation routines. Similarly I can easily generate multiple outputs without complicating my parse. I can also use both an interpreted model and code generation off the sameSemantic Model. As a result for almost all of this book, I m going to assume aSemantic Modelis present and the centre of the DSL effort. Using Language Workbenches The two styles of DSL I ve shown so far (internal and external) are the traditional ways of thinking about DSLs. They may not be as widely understood and used as they should be, but they have a long history and moderately wide usage. As a result the rest of this book concentrates on getting you started with these approaches using tools that are mature and easy to obtain. But there is a whole new category of tools on the horizon that could change the game of DSLs significantly tools I call Language Workbenches. ALanguage Workbenchis tool designed to help people create new DSLs, together with high quality tooling required to use those DSLs effectively. One of the big disadvantages of using an external DSL is that you re stuck with relatively limited tooling. Setting up syntax highlighting with a text editor is about as far as most people go. While you can argue that the simplicity of a DSL and the small size of the scripts means that may be enough, there s also an argument for the kind of sophisticated tooling that modern post-IntelliJ IDEs support. Language Workbenches make it easy not just to define a parser, but also to define a custom editing environment for that language. All of this is valuable, but the truly interesting aspect of language workbenches is that they allow a DSL designer to go beyond the the traditional text-based source editing, to different forms of language. The most obvious example of this is support for diagrammatic languages, which would allow me to specify the secret panel state machine directly with a state transition diagram. Figure 3 The secret panel state machine displayed in the MetaEdit language workbench.(source MetaCase) Not just does a tool like this allow you to have diagrammtic languages, it also allows you to look at a DSL script from multiple perspectives. In Figure3there is a diagram, but also lists of states and events, and a table to enter the event codes (which could be ommitted from the diagram if there s too much clutter there). This kind of multi-pane visual editing environment has been around for a while in lots of tools, but it s been a lot of effort to build something like this for yourself. One promise of language workbenches is that they make it quite easy to do this, certainly I was easily able to put together a similar example to Figure3quite quickly on my first play with the MetaEdit tool. The tools allows me to define theSemantic Modelfor state machines, define the graphical and tabular editors in Figure3and write a code generator from theSemantic Model. However, while such tools certainly look good, many developers are naturally suspicious of such doodleware tools. There are some very pragmatic reasons why a textual source representation makes sense. As a result other tools head in that direction, providing post-IntelliJ style capabilities such as syntax-directed editing, symbol completion and the like to textual languages. My own suspicion here is that if language workbenches really take off, the languages they ll produce aren t anything like what we consider to be a programming language. One of the common benefits of tools like this is that they allow non-programmers to program. I often sniff at that notion by pointing out that this was the original intent of COBOL. Yet I must also acknowledge a programming environment that has been extremely successful in providing programming tools to non-programmers who program without thinking of themselves of programming - spreadsheets. In programming language terms spreadsheets are based on a quite unusual computational model. Their appeal comes from a very deep integration of the notions of language and tool. Thus it s no surprise that Charles Simonyi combines both a history of development of these kinds of user tools with a long history of developing ideas in language workbenches. As a result I think that language workbenches have a remarkable potential. If they fulfill this they could entirely change the face of software development. This potential, however profound, is still somewhat in the future. It s still early days for language workbenches with new approaches appearing regularly and older tools still subject to deep evolution. As a result I don t have that much to say about them here, as I think they will change quite dramatically during the hoped-for lifetime of this book. But I do have a chapter on them at the end, as I think they are well worth keeping an eye on. Visualization One the great advantages of using a Language Workbench is that this enables you to a wider range of representations of the DSL, in particular graphical representations. However even with a textual DSL you can obtain a diagrammatic representation. Indeed we saw this very early on in this chapter. When looking at Figure1it might have struck you that the diagram was not as neatly drawn as I usually do. The reason for this is that I didn t draw the diagram, I generated it automatically from theSemantic Modelof Miss Grant s controller. Not just do my state machine classes execute, they also are able to render themselves use the dot language. The dot langauge is part of the GraphViz package, which is an open-source tool that allows you to describe mathematical graph structures (nodes and edges) and then automatically plot them. It figures out how to lay out the graph, you just tell it what the nodes and edges are, what shapes to use, and some other hints. Using a tool like GraphViz is extremely helpful for many kinds of DSLs because it gives another representation. Thisvisualizationrepresentation is similar to the DSL itself in that it allows a human to understand the model. The diference between a visualization and the source is that it isn t editable - however it can provide options that are too hard in an editable form, such as a diagram like this. In the terms of a language workbench you can think of a visualization as a read-only projection. It s something that can be less important for graphical language workbenches, since you use a diagram anyway, but it s still sometimes a handy technique. Visualizations don t have to be graphical. I often use a simple textual visualization to help me debug while I m writing a parser. I ve seen people generate visualizations in Excel to help communicate with domain experts. The point is that once you have done the hard work of creating a component framework like this, adding visualizations is really easy. You ll note here that the visualizations are produced from the framework, not the DSL, so you can do this even if you aren t using a DSL to populate the framework. Indeed the techniques in this book can be used for creating visualizations above and beyond DSL usage. A partial parser for a general purpose language can be used to visualize useful aspects of a general purpose program. Any interesting data strucutre can be visualized in interesting ways. Significant Revisions 06 Aug 07 First Draft 09 Apr 08 Split example from general issues
https://w.atwiki.jp/shift2/pages/13.html
収録車種 収録車種一覧 カテゴリ別一覧Modern Road Modern GTX Modern GT3 Modern GT1 Modern,Muscle Road Modern Drift Modern Time Attack Muscle,Legends Road Muscle,Legends 60s GT Retro Road Retro GTX 収録車種一覧 メーカー 車名 クラス カテゴリー 獲得条件 Acura NSX C 510 Modern Road Alfa Romeo 8C Competizione C 910 Modern Road 8C Spider C 900 Modern Road S2U Unofficial Community Patch Giulia Sprint GTA D 185 legends 60s GT Limited Edition Giulietta QV D 340 Modern Road DLC Alpina B6 GT3 A 1590 Modern GT3 Aston Martin DB9 Coupe C 989 Modern Road V8 Vantage N400 C 800 Modern Road Aston Martin Racing DBR9 GT1 A 1810 Modern GT1 DBRS9 GT3 A 1590 Modern GT3 Audi R8 Coupe 4.2 FSI quattro C 920 Modern Road R8 LMS A 1590 Modern GT3 RS4 C 710 Modern Road S3 D 370 Modern Road S4 D 480 Modern Road TT Coupe 3.2 quattro D 460 Modern Road Bentley Continental Supersports B 1050 Modern Road BMW 135i Coupe D 400 Modern Road M1 Procar B 1370 Retro GTX M3 E30 Sport Evolution D 400 Retro Road M3 E36 D 419 Retro Road M3 E46 C 530 Modern Road M3 E92 C 740 Modern Road M3 GT ALMS A 1530 Modern GTX ENDURANCE勝利 M6 Coupe C 880 Modern Road Z4 M Coupe C 610 Modern Road Z4 sDrive35is C 510 Modern Road Team Need For Speed BMW Z4 GT3 A 1590 Modern GT3 GT3勝利 Bugatti Veyron 16.4 A 1640 Modern Road Caterham Superlight R500 C 889 Modern Road Chevrolet Camaro SS C 740 Modern,Muscle Road Cobalt SS D 430 Modern Road Corvette C6.R GT1 A 1810 Modern GT1 Corvette Stingray C 550 Muscle,Legends Road Corvette Z06 B 1160 Modern,Muscle Road Modern B Invitational勝利 Corvette Z06R GT3 A 1590 Modern GT3 Dodge Challenger Concept C 660 Modern,Muscle Road Viper SRT10 B 1140 Modern,Muscle Road Challenger R/T C 515 Muscle,Legends Road Charger R/T C 520 Muscle,Legends Road Ford Escort RS Cosworth D 190 Retro Road Focus RS C 505 Modern Road Focus ST D 300 Modern Road GT B 1150 Modern Road SHELBY GT500 C 770 Modern,Muscle Road Matech Ford GT GT1 A 1810 Modern GT1 Matech Ford GT GT3 A 1590 Modern GT3 Monster Energy/Falken Tire Ford Racing Mustang B 1250 Modern Drift DRIFT勝利 Need For Speed Shelby Terlingua Ford Mustang C 760 Modern Road DRIVER Level 10 Team Need For Speed Ford Mustang RTR-X B 1270 Modern,Muscle Road MUSCLE勝利 GUMPERT apollo A 1829 Modern Road Honda Civic Si D 190 Modern Road S2000 CR D 430 Modern Road Infiniti G35 (V35) D 480 Modern Road Jaguar XKR C 930 Modern Road Koenigsegg CCX A 1820 Modern Road Lamborghini Gallardo LP560 GT3 A 1590 Modern GT3 Gallardo LP560-4 B 1070 Modern Road Murcielago LP640 B 1320 Modern Road Limited Edition Murcielago R-SV GT1 A 1810 Modern GT1 Reventon B 1310 Modern Road Reventon Police A 1850 Modern Road NFSHPセーブデータ Lancia Delta HF Integrale Evoluzione D 419 Retro Road Lexus IS F C 740 Modern Road LFA B 1100 Modern Road Lotus Elise 111R D 460 Modern Road Exige S C Modern Road Modern C Invitational勝利 Maserati GranTurismo S C 839 Modern Road MC12 GT1 A 1810 Modern GT1 Mazda MX-5 D 280 Modern Road RX-7 (FC3S) D 170 Retro Road RX-7 (FD3S) D 440 Retro Road RX-8 D 320 Modern Road Team Need For Speed Mazda RX-7 A 1750 Modern GTX Works勝利 Team Need for Speed Mazda RX-8 A 1505 Modern Drift DRIVER LEVEL 5 McLaren F1 A 1660 Retro Road MP4-12C A Modern Road Modern A Invitational勝利 Mercedes-Benz 190E 2.5-16 Evolution 2 D 380 Retro Road SL 65 AMG C 939 Modern Road SLS AMG B 1070 Modern Road SLR McLaren 722 Edition B 1170 Modern Road SLR McLaren Stirling Moss B 1250 Modern Road MINI Austin Mini Cooper S D 5 Legend 60s GT DLC Mitsubishi Lancer EVOLUTION IX MR-edition C 530 Modern Road Lancer EVOLUTION X C 515 Modern Road Nissan 200SX (S14) D 209 Retro Road 240SX (S13) D 70 Retro Road 350Z (Z33) C 570 Modern Road 370Z (Z34) C 600 Modern Road GT-R (R35) C 980 Modern Road GT-R (R35) C 980 Modern Road GT-R GT1 A 1810 Modern GT1 GT1勝利 GT-R SpecV (R35) B 1150 Modern Road GT-R SpecV (R35) JCW Edition A 1660 Modern Road Modern A勝利 Silvia spec.R AERO (S15) D 480 Modern Road Limited Edition Skyline GT-R (R32) D 469 Retro Road Skyline GT-R (R34) C 600 Mordern Road Pagani Huayra A 1870 Modern Road Zonda Cinque Rodster Hot Pursuit Edition A 2070 Modern Road NFSHPセーブデータ Zonda F A 1650 Modern Road Zonda R A 1950 Modern GTX Porsche 911 GT2 B 1130 Modern Road 911 GT3 Cup R A 1590 Modern GT3 911 GT3 RS C 980 Modern Road 911 GT3 RSR A 1520 Modern GTX 911 GT3 RSR 2009.team Falken A 1520 Modern GTX DRIVER LEVEL 15 918 Spyder Concept Study A 1580 Modern Road Carrera GT A 1570 Modern Road Cayman S C 750 Modern Road Radical SR3 RS A 1629 Modern GTX Renault SPORT MEGANE R.S. D 220 Modern Road SCION tC D 150 Modern Road Team Need For Speed AWD SCION tC A 1950 Modern Time Attack Time Attack勝利 SEAT Leon CUPRA D 250 Modern Road SHELBY COBRA 427 C 690 Muscle,Legends 60s GT GT500 C 520 Muscle,Legends Road Subaru Impreza WRX STI C 520 Modern Road Toyota Corolla GTS (AE86) D 100 Retro Road Team Need For Speed Toyota Corolla GTS (AE86) A 1510 Retro GTX RETRO勝利 Supra C 550 Retro Road Volkswagen Golf GTI D 245 Modern Road Golf Mk1 GTI D 50 Retro Road Scirocco D 260 Modern Road カテゴリ別一覧 Modern Road メーカー 車名 クラス カテゴリー 獲得条件 Acura NSX C 510 Modern Road Alfa Romeo 8C Competizione C 910 Modern Road Giulietta QV D 340 Modern Road Limited Edition Aston Martin DB9 Coupe C 989 Modern Road V8 Vantage N400 C 800 Modern Road Audi R8 Coupe 4.2 FSI quattro C 920 Modern Road RS4 C 710 Modern Road S3 D 370 Modern Road S4 D 480 Modern Road TT Coupe 3.2 quattro D 460 Modern Road Bentley Continental Supersports B 1050 Modern Road BMW 135i Coupe D 400 Modern Road M3 E46 C 530 Modern Road M3 E92 C 740 Modern Road M6 Coupe C 880 Modern Road Z4 M Coupe C 610 Modern Road Z4 sDrive35is C 510 Modern Road Bugatti Veyron 16.4 A 1640 Modern Road Caterham Superlight R500 C 889 Modern Road Chevrolet Cobalt SS D 430 Modern Road Ford Focus RS C 505 Modern Road Focus ST D 300 Modern Road GT B 1150 Modern Road Need For Speed Shelby Terlingua Ford Mustang C 760 Modern Road DRIVER Level 10 GUMPERT apollo A 1829 Modern Road Honda Civic Si D 190 Modern Road S2000 CR D 430 Modern Road Infiniti G35 (V35) D 480 Modern Road Jaguar XKR C 930 Modern Road Koenigsegg CCX A 1820 Modern Road Lamborghini Gallardo LP560-4 B 1070 Modern Road Murcielago LP640 B 1320 Modern Road Limited Edition Reventon B 1310 Modern Road Reventon Police A 1850 Modern Road NFSHPセーブデータ Lexus IS F C 740 Modern Road LFA B 1100 Modern Road Lotus Elise 111R D 460 Modern Road Exige S C Modern Road Modern C Invitational勝利 Maserati GranTurismo S C 839 Modern Road Mazda MX-5 D 280 Modern Road RX-8 D 320 Modern Road McLaren MP4-12C A Modern Road Modern A Invitational勝利 Mercedes-Benz SL 65 AMG C 939 Modern Road SLS AMG B 1070 Modern Road SLR McLaren 722 Edition B 1170 Modern Road SLR McLaren Stirling Moss B 1250 Modern Road Mitsubishi Lancer EVOLUTION IX MR-edition C 530 Modern Road Lancer EVOLUTION X C 515 Modern Road Nissan 350Z (Z33) C 570 Modern Road 370Z (Z34) C 600 Modern Road GT-R (R35) C 980 Modern Road GT-R (R35) Need For Speed Edition B 1180 Modern Road GT-R SpecV (R35) B 1150 Modern Road GT-R SpecV (R35) JCW Edition A 1660 Modern Road Modern A勝利 Silvia spec.R AERO (S15) D 480 Modern Road Limited Edition Pagani Huayra A 1870 Modern Road Zonda Cinque Rodster Hot Pursuit Edition A 2070 Modern Road NFSHPセーブデータ Zonda F A 1650 Modern Road Porsche 911 GT2 B 1130 Modern Road 911 GTR Cup R A 1590 Modern GT3 911 GT3 RS C 980 Modern Road 918 Spyder Concept Study A 1580 Modern Road Carrera GT A 1570 Modern Road Cayman S C 750 Modern Road Renault SPORT MEGANE R.S. D 220 Modern Road SCION tC D 150 Modern Road SEAT Leon CUPRA D 250 Modern Road Subaru Impreza WRX STI C 520 Modern Road Volkswagen Golf GTI D 245 Modern Road Scirocco D 260 Modern Road Modern GTX メーカー 車名 クラス カテゴリー 獲得条件 BMW M3 GT ALMS A 1530 Modern GTX ENDURANCE勝利 Mazda Team Need For Speed Mazda RX-7 A 1750 Modern GTX Works勝利 Pagani Zonda R A 1950 Modern GTX Porsche 911 GT3 RSR A 1520 Modern GTX 911 GT3 RSR 2009.team Falken A 1520 Modern GTX DRIVER LEVEL 15 Radical SR3 RS A 1629 Modern GTX Modern GT3 メーカー 車名 クラス カテゴリー 獲得条件 Alpina B6 GT3 A 1590 Modern GT3 Aston Martin Racing DBRS9 GT3 A 1590 Modern GT3 Audi R8 LMS A 1590 Modern GT3 BMW Team Need For Speed BMW Z4 GT3 A 1590 Modern GT3 GT3勝利 Chevrolet Corvette Z06R GT3 A 1590 Modern GT3 Ford Matech Ford GT GT3 A 1590 Modern GT3 Lamborghini Gallardo LP560 GT3 A 1590 Modern GT3 Porsche 911 GT3 Cup R A 1590 Modern GT3 Modern GT1 メーカー 車名 クラス カテゴリー 獲得条件 Aston Martin Racing DBR9 GT1 A 1810 Modern GT1 Chevrolet Corvette C6.R GT1 A 1810 Modern GT1 Ford Matech Ford GT GT1 A 1810 Modern GT1 Lamborghini Murcielago R-SV GT1 A 1810 Modern GT1 Maserati MC12 GT1 A 1810 Modern GT1 Nissan GT-R GT1 A 1810 Modern GT1 GT1勝利 Modern,Muscle Road メーカー 車名 クラス カテゴリー 獲得条件 Chevrolet Camaro SS C 740 Modern,Muscle Road Corvette Z06 B 1160 Modern,Muscle Road Modern B Invitational勝利 Dodge Challenger Concept C 660 Modern,Muscle Road Viper SRT10 B 1140 Modern,Muscle Road Ford SHELBY GT500 C 770 Modern,Muscle Road Team Need For Speed Ford Mustang RTR-X B 1270 Modern,Muscle Road MUSCLE勝利 Modern Drift メーカー 車名 クラス カテゴリー 獲得条件 Ford Monster Energy/Falken Tire Ford Racing Mustang B 1250 Modern Drift DRIFT勝利 Mazda Team Need for Speed Mazda RX-8 A 1505 Modern Drift DRIVER LEVEL 5 Modern Time Attack メーカー 車名 クラス カテゴリー 獲得条件 Scion Team Need For Speed AWD SCION tC A 1950 Modern Time Attack Time Attack勝利 Muscle,Legends Road メーカー 車名 クラス カテゴリー 獲得条件 Chevrolet Corvette Stingray C 550 Muscle,Legends Road Dodge Challenger R/T C 515 Muscle,Legends Road Charger R/T C 520 Muscle,Legends Road SHELBY GT500 C 520 Muscle,Legends Road Muscle,Legends 60s GT メーカー 車名 クラス カテゴリー 獲得条件 SHELBY COBRA 427 C 690 Muscle,Legends 60s GT Retro Road メーカー 車名 クラス カテゴリー 獲得条件 BMW M3 E30 Sport Evolution D 400 Retro Road M3 E36 D 419 Retro Road Ford Escort RS Cosworth D 190 Retro Road Lancia Delta HF Integrale Evoluzione D 419 Retro Road Mazda RX-7 (FC3S) D 170 Retro Road RX-7 (FD3S) D 440 Retro Road McLaren F1 A 1660 Retro Road Mercedes-Benz 190E 2.5-16 Evolution 2 D 380 Retro Road Nissan 200SX (S14) D 209 Retro Road 240SX (S13) D 70 Retro Road Skyline GT-R (R32) D 469 Retro Road Toyota Corolla GTS (AE86) D 100 Retro Road Supra C 550 Retro Road VW Golf Mk1 GTI D 50 Retro Road Retro GTX メーカー 車名 クラス カテゴリー 獲得条件 BMW M1 Procar B 1370 Retro GTX Toyota Team Need For Speed Toyota Corolla GTS (AE86) A 1510 Retro GTX RETRO勝利
https://w.atwiki.jp/kotatsuland/pages/62.html
第3回 2/24 HEURES DU MANS レースを完走した勇者たち KLMPクラス 10/20（木） 順位はリザルト画面の着順。 順位 チーム名 車輌名 ドライバー 1 THREE COLOR AUDI RACING AUDI R8 ｋｈ 2 不正車両 TOYOTA GT-One しゃいお 3 不正車両 TOYOTA GT-One ｱｷﾗﾝ 4 THREE COLOR AUDI RACING AUDI R8 おかさん 5 ｳｨﾘｱﾑｽﾞLMｴｸｽﾍﾟﾘｴﾝｽ BMW V12 LMR 蠍丸 6 ﾛﾘｰﾀｴﾝｼﾞﾝ愛好家 MAZDA 787B KL 7 TV KANAGAWA TEAM DRAGON PANOZ GTR-1 Morris 8 m9 RACING PEUGEOT 908 L君 9 m9 RACING PEUGEOT 908 デジ 10 (緊急参戦) PESCAROLO C60 リリウィ 11 ｳｨﾘｱﾑｽﾞLMｴｸｽﾍﾟﾘｴﾝｽ BMW V12 LMR めんタマゴ - m9 RACING PEUGEOT 908 グリム※1 - ﾛﾘｰﾀｴﾝｼﾞﾝ愛好家 MAZDA 787B カジキ※1 - THREE COLOR AUDI RACING AUDI R8 洗濯物※2 - 不正車両 TOYOTA GT-One かずっち※3 ※1…回線落ちにより、完走ならず。 ※2…私事都合により、当日欠場。 ※3…家庭系トラブルにより、当日欠場。 KLM-GTクラス 10/19（水） 順位はリザルト画面の着順。 順位 チーム名 車輌名 ドライバー 1 PRESTO E COMFORT CHEVROLET CORVETTE ぶらぜる 2 ﾚﾓﾈｰﾄﾞPACIFIC NAC ｲｶ娘 ﾊﾟｶﾞｰﾆ PAGANI ZONDA たこ 3 ﾚﾓﾈｰﾄﾞPACIFIC NAC ｲｶ娘 ﾊﾟｶﾞｰﾆ PAGANI ZONDA L君 4 CHAMBERLAIN SYNERGY MOTORSPORT TVR TUSCAN Morris 5 TEAM KUNIMITSU HONDA HONDA NSX 小日向はやみ 6 TEAM 3RD STAGE B×4R TOYOTA SUPRA バナナ 7 SCUDERIA TERRARI FERRARI 458 まめ 8 ぶりぶりﾚｰｼﾝｸﾞ RUF BTR ヴォルフィー 9 TEAM YUTO LAMBORGHINI LAMBORGHINI LP670 F1優斗!! 10 PRESTO E COMFORT CHEVROLET CORVETTE とぉ 11 TEAM 3RD STAGE B×4R TOYOTA SUPRA レーヴ 12 FORD RACING TEST FORD GT デジ 13 FUTATSUYAMA RACING ASTON MARTIN DB9 リリウィ 14 MAZDA WITH RED SUNS MAZDA RX-7 カジキ - JAGUAR RSR TEAM JAGUAR XKR じゃくお※ ※…回線落ちのため、完走ならず。
https://w.atwiki.jp/grasoturismo/pages/274.html
アストンマーティン DB11 '16 Image Credit Emula / Gran Turismo Archive メーカー アストンマーティン 英名 Aston Martin DB11 '16 エンジン AE31 タイプ ロードカー カテゴリー N600 PP（初期値） 578.52 総排気量 5,204cc 最高出力 608ps/6,500rpm 最大トルク 71.4kgfm/1,500rpm パワーウエイトレシオ 2.91kg/PS 駆動形式 FR 吸気形式 TB 全長 4,739mm 全幅 2,060mm 全高 1,279mm 車両重量 1,770kg 重量バランス XX対XX トランスミッション 8速 最高速度 322km/h (フルノーマル時) 登場 グランツーリスモSPORTグランツーリスモ7 備考 あれば記入 概要 アストンマーティンを代表する2＋2クーペで、戦後同社を経営していたデービッド・ブラウンの名を冠したスポーティモデル、DBシリーズがフルモデルチェンジ。 DB9 の後継にあたる。 歴代DBシリーズのイメージを受け継ぎながら、新たなデザイン哲学が導入されたことで、エクステリアが刷新された。内装は伝統のクラフトマンシップに最新のインフォテイメントテクノロジーが加わり、快適さと利便性との両立が図られている。駆動方式はFR、エンジンは最高出力608ps／最大トルク700N・mを発生する新型5.2L V12ツインターボ。ZF製8速ATとの組み合わせで0－100km/h加速は3.9秒を実現しており、最高速度はシリーズ最速の322km/hに達する。 ちなみにV8モデルも存在するが、こちらはメルセデス・ベンツ製のV8ツインターボエンジンを搭載している、不等長エキマニによるホットVレイアウトというのもあり、アメ車を彷彿とさせるドロドロとした排気音を奏でる。 なおこのV8モデルが同社としては初のターボエンジン搭載モデルだったりする。 解説 DB11は2016年のジュネーブショーで発表された、 アストンマーティンのメインストリームといえるGTカー。 2004年から12年にわたって作られたDB9の後継モデルである。 ロングノーズのクーペというアストンマーティンの伝統的なシルエットを持ちながら、 それまでのプロダクション・アストンマーティンとは一線を画すモダンなディテールを持つエレガントなスタイリングは、副社長であり造形部門のトップでもあるマレック・ライヒマンの手によるもの。フロントグリルやCピラーから空気を取り入れ車体内部を経由して排出することで、リフト防止やダウンフォース確保を狙うなど、 空力効果を生み出している。 基本骨格は従来のものを大きく発展させた完全新設計のアルミ接着型、新VHプラットフォーム。そのフロントアクスルからコックピットの間に、 やはり新たに開発された5.2LのV型12気筒ツインターボを搭載する。 最高出力は608 PS、 最大トルクは71.4kgfm。ZF製8速ATとの組み合わせで0-100 km/h3.9秒、 最高速度322 km/hという、 スーパーカー並みのパフォーマンスを実現した。 登場シリーズ グランツーリスモSPORT グランツーリスモ7 ブランドセントラルにてCr.23,800,000で購入可能。スーパーカー系としては平均的な値段。だが､問題は競合するライバル車の存在だろう。同価格帯もしくはより安価で同等以上のパフォーマンスを持つ車も少なくないので、好みに合うなら選んでもいい。 コメント 名前 コメント すべてのコメントを見る
https://w.atwiki.jp/f_motorsport/pages/32.html
A クラス 駆動形式 PI値 車名 価格 速度 加速 ブレーキング ハンドリング 希少度 FR 701 2005 Aston Martin DB9 Coupe - - - - - - MR 718 1994 Ferrari F355 Berlinetta - - - - - - FR 726 2002 BMW Motorsport M3-GTR - - - - - - 4WD 727 1999 Mitsubishi Mine's CP9A Lancer EVO VI - - - - - - MR 734 1999 Ferrari 360 Modena - - - - - - FF 736 2003 Ford FocusSport SVT Focus - - - - - - FR 737 1999 Shelby Series 1 - - - - - - RR 739 2004 Porsche 911 GT3 (996) - - - - - - FR 739 2005 Ferrari 612 Scaglietti - - - - - - FR 742 2003 Nissan Fairlady Z Custom Edition - - - - - - FR 751 2001 TVR Tuscan S - - - - - - FR 751 2002 Ferrari 575M Maranello - - - - - - 4WD 755 1987 Porsche 959 - - - - - - FR 756 2002 Chevrolet Corvette Z06 - - - - - - MR 757 1988 Lamborghini Countack LP5000 QV - - - - - - 4WD 759 2005 Lamborghini Gallardo - - - - - - FR 762 2006 Saleen S281 E - - - - - - FR 765 1965 Shelby Cobra 427 S/C - - - - - - 4WD 766 2007 Porsche 911 Turbo (997) - - - - - - FR 774 1999 Dodge Viper GTS ACR - - - - - - 駆動形式 PI値 車名 価格 速度 加速 ブレーキング ハンドリング 希少度 MR 779 1984 Ferrari GTO - - - - - - FR 790 2003 Chevrolet Corvette Guldstrand Edition - - - - - - RR 790 2007 Porsche 911 GT3 (997) - - - - - - RR 794 1995 Porsche 911 GT2 - - - - - - MR 796 1997 Lamborghini Diablo SV - - - - - - 4WD 797 2003 Mitsubishi Sparco Lancer Evolution VIII - - - - - - MR 798 2004 Ferrari F430 - - - - - - MR 800 1998 Ferrari F355 Challenge - - - - - - FR 806 2005 TVR Sagaris - - - - - - FR 807 2003 Dodge Viper SRT10 - - - - - - MR 808 2003 Ferrari Challenge Stradale - - - - - - 4WD 819 2005 Lamborghini Murcielago - - - - - - 4WD 832 2000 Audi AWE Tuning SilverBullet S4 - - - - - - FR 834 2001 TVR Tuscan R - - - - - - FR 834 2005 Mercedes SLR - - - - - - MR 838 2005 Ford Ford GT - - - - - - FR 841 2006 Chevrolet Corvette Z06 - - - - - - FR 846 1995 Mazda RE-Amemiya RX-7 - - - - - -
https://w.atwiki.jp/realracing3japan/pages/26.html
概要 特定の車種に「限定シリーズ」というキャリアが存在する。 限定シリーズは特定の車種をフルアップグレードする事で解放される。 （ほかにドライバーレベルを５にする必要がある） 難易度が高く、自身の腕が試される。 攻略のコツ レベルは最後になるにつれて難易度が高い。 元々最初から挑戦が出来るので、あえて最後から最初の方へ進めるという方法もできる。 全体的に難易度が高いため、オンライン状態で進めていくと難しくなる。 出来れば機内モード状態で攻略すれば比較的に楽に終わらせる。 ★小ネタ 報酬が良いエンデュランスはクルーを惜しみなく使おう。 今後の進行に影響が出るため意識しよう。 Ｇの余裕がある場合はカップでも使うようにするともっと良くなる。 車種一覧（Ｒ＄） Nissan Skyline GT-R V-Spec (R34) BMW M3 GTS Jaguar F-Type SVR Ariel Atom V8 Ferrari FXX K Lamborghini Gallardo LP560-4 Ferrari F12tdf Koenigsegg Regera Audi R8 LMS Ultra McLaren P1™ GTR McLaren MP4-X Porsche 918 RSR Concept Mercedes-AMG GT3 Aston Martin V12 Vantage S Ferrari F14 T Koenigsegg One 1 Mazda RX-7 Sprit R (FD) Mazda Furai McLaren 720S Coupe Bugatti Veyron 16.4 Aston Martin Vantage AMR Pro Ford GT (2017) Nissan Silvia (S15) R3 Spec Lotas Type 125 Aston Martin Vantage GTE (2017) McLaren MP4/4 Ferrari Testarossa Lamborghini Huracán Performante Ferrari 812 Superfast Porsche 911 GT1-98 Mercedes-Benz 190E 2.5-16 Evolution Ⅱ Mercedes-Benz C11 Porsche 936/77 Spyder Pagani Huayra BC BMW M1 Porsche 911 GT2 RS Ferrari FXX K Evo Nissan 370Z Nismo Nissan 240Z (S30) R3 Spec Nissan GT-R (R35) R3 Spec Hennessey Venom GT Mercedes-Benz CLK-LM Dodge Challenger SRT Hellcat Lamborghini Centenario LP 770-4 Jaguar C-X75 Honda NSX-R Porsche 919 Hybrid Evo Renault R.S. 01 Lamborghini Veneno Ferrari Enzo Ferrari McLaren 650S GT3 Porsche 911 GT2 RS Clubsport Pagani Zonda R Ferrari F8 Tributo Lamborghini Aventador SVJ Jaguar XJ220 Koenigsegg Agera RS Aston Martin Vulcan Honda Civic Type-R BMW M5 Ferrari 488 GT3 McLaren Senna GTR Ford GT Le Mans (2019) Ferrari F40 LM [[]] 車種一覧（Ｍ＄） McLaren 720S GT3 Porsche 911 GT3 R [[]]